package com.atguigu.gmall.product.service.impl;

import com.atguigu.gmall.common.execption.GmallException;
import com.atguigu.gmall.model.product.BaseAttrInfo;
import com.atguigu.gmall.model.product.BaseAttrInfoVO;
import com.atguigu.gmall.model.product.BaseAttrValue;
import com.atguigu.gmall.model.product.BaseAttrValueVO;
import com.atguigu.gmall.product.mapper.BaseAttrInfoMapper;
import com.atguigu.gmall.product.mapper.BaseAttrValueMapper;
import com.atguigu.gmall.product.service.BaseAttrInfoService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.List;

/***
 * 商品属性信息service层的接口实现类
 */
@Service
@Transactional(rollbackFor = Exception.class)
public class BaseAttrInfoServiceImpl implements BaseAttrInfoService {

    @Autowired
    private BaseAttrInfoMapper baseAttrInfoMapper;

    @Autowired
    private BaseAttrValueMapper baseAttrValueMapper;

    /**
     * 条件分页查询
     *  @param baseAttrInfo
     * @param pageNum
     * @param size
     * @return
     */
    @Override
    public IPage search(BaseAttrInfo baseAttrInfo, Integer pageNum, Integer size) {
        //分页对象
        Page<BaseAttrInfo> page = new Page<>(pageNum, size);

        //条件构造器
        LambdaQueryWrapper lambdaQueryWrapper = buildQueryParam(baseAttrInfo);

        //分页操作
        IPage iPage = baseAttrInfoMapper.selectPage(page, lambdaQueryWrapper);

        //返回结果
        return iPage;
    }

    /**
     * 条件查询
     *
     * @return
     */
    @Override
    public List<BaseAttrInfo> search(BaseAttrInfo baseAttrInfo) {
        //条件构造器
        LambdaQueryWrapper lambdaQueryWrapper = buildQueryParam(baseAttrInfo);

        //返回结果
        List<BaseAttrInfo> baseAttrInfos = baseAttrInfoMapper.selectList(lambdaQueryWrapper);
        return baseAttrInfos;
    }

    /**
     * 分页查询
     *  @param pageNum
     * @param size
     * @return
     */
    @Override
    public IPage<BaseAttrInfo> page(Integer pageNum, Integer size) {
        return baseAttrInfoMapper.selectPage(new Page(pageNum, size), null);
    }

    /**
     * 根据主键id删除
     *
     * @param id
     */
    @Override
    public void removeById(Long id) {
        //校验参数
        if(id == null){
            return;
        }

        //删除操作
        int delete = baseAttrInfoMapper.deleteById(id);
        //判断操作是否成功
        if(delete < 0){
            throw new GmallException("删除失败",null);
        }
    }

    /**
     * 根据主键id修改
     *
     * @param baseAttrInfo
     */
    @Override
    public void editById(BaseAttrInfo baseAttrInfo) {
        //校验参数
        if (baseAttrInfo == null) {
            throw new GmallException("参数错误", null);
        }

        //修改操作
        int update = baseAttrInfoMapper.updateById(baseAttrInfo);
        //判断是否成功
        if (update < 0) {
            throw new GmallException("修改失败，请重试！", null);
        }
    }

    /**
     * 新增数据
     *
     * @param baseAttrInfo
     */
    @Override
    public void save(BaseAttrInfo baseAttrInfo) {
        //校验参数
        if (baseAttrInfo == null ||
                StringUtils.isEmpty(baseAttrInfo.getAttrName())) {
            throw new GmallException("参数错误", -1);
        }

        //新增操作
        int insert = baseAttrInfoMapper.insert(baseAttrInfo);
        if (insert <= 0) {
            throw new GmallException("新增失败", null);
        }

        //平台属性值表插入数据
        //获取平台属性表id
        Long id = baseAttrInfo.getId();
        List<BaseAttrValue> attrValueList = baseAttrInfo.getAttrValueList();
        attrValueList.stream().forEach(attrValue -> {
            //校验数据
            if(StringUtils.isEmpty(attrValue.getValueName())){
                return;
            }
            attrValue.setAttrId(id);
            int insert1 = baseAttrValueMapper.insert(attrValue);
            if(insert1 <= 0){
                throw new GmallException("新增失败", null);
            }
        });

    }

    /**
     * 根据id查
     *
     * @param id
     * @return
     */
    @Override
    public BaseAttrInfo getById(Long id) {
        return baseAttrInfoMapper.selectById(id);
    }

    /**
     * 查询所有数据
     *
     * @return
     */
    @Override
    public List<BaseAttrInfo> list() {
        return baseAttrInfoMapper.selectList(null);
    }

    /**
     * 根据三级分类id查询平台属性数据
     *
     * @param category3Id
     * @return
     */
    @Override
    public List<BaseAttrInfoVO> listByCategory3Id(Long category3Id) {
//        //1 查出平台属性数据
//        LambdaQueryWrapper<BaseAttrInfo> queryWrapper = new LambdaQueryWrapper<>();
//        queryWrapper.eq(BaseAttrInfo::getCategoryId,category3Id);
//        List<BaseAttrInfo> baseAttrInfos = baseAttrInfoMapper.selectList(queryWrapper);
//
//        //2 拿平台属性id查平台属性值
//        baseAttrInfos.stream().forEach(baseAttrInfo -> {
//            List<BaseAttrValue> baseAttrValueList = baseAttrValueMapper.
//                    selectList(new LambdaQueryWrapper<BaseAttrValue>()
//                            .eq(BaseAttrValue::getAttrId, baseAttrInfo.getId()));
//
//            baseAttrInfo.setAttrValueList(baseAttrValueList);
//        });

        //数据库查询
        List<BaseAttrInfo> baseAttrInfoList = baseAttrInfoMapper.selectBaseAttrInfoByCategory3Id(category3Id);

        List<BaseAttrInfoVO> baseAttrInfoVOList = new ArrayList<>();
        BaseAttrInfoVO baseAttrInfoVO = new BaseAttrInfoVO();

        //遍历平台属性集合
        baseAttrInfoList.stream().forEach(baseAttrInfo -> {
            BeanUtils.copyProperties(baseAttrInfo,baseAttrInfoVO);
            //用来存BaseAttrValueVO
            ArrayList<BaseAttrValueVO> attrValueVOList = new ArrayList<>();
            //获取到平台属性值集合
            List<BaseAttrValue> attrValueList = baseAttrInfo.getAttrValueList();
            //遍历平台属性值集合
            attrValueList.stream().forEach(attrValue -> {
                BaseAttrValueVO baseAttrValueVO = new BaseAttrValueVO();
                BeanUtils.copyProperties(attrValue,baseAttrValueVO);
                baseAttrValueVO.setId(attrValue.getId().toString());
                attrValueVOList.add(baseAttrValueVO);
            });
            baseAttrInfoVO.setAttrValueList(attrValueVOList);
            baseAttrInfoVOList.add(baseAttrInfoVO);
        });

        //3 返回
        return baseAttrInfoVOList;
    }

    /**
     * 拿到指定skuId的商品的平台属性和属性值集合
     *
     * @param skuId
     * @return
     */
    @Override
    public List<BaseAttrInfo> listBySkuId(Long skuId) {
        //1 调用持久层的方法
        List<BaseAttrInfo> baseAttrInfoList = baseAttrInfoMapper.selectListBySkuId(skuId);

        //2 返回
        return baseAttrInfoList;
    }

    /**
     * 构建查询构造器
     * @param baseAttrInfo
     * @return
     */
    protected LambdaQueryWrapper buildQueryParam(BaseAttrInfo baseAttrInfo){
        //条件构造器
        LambdaQueryWrapper<BaseAttrInfo> baseAttrInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();

        //判断id
        if (baseAttrInfo.getId() != null) {
            baseAttrInfoLambdaQueryWrapper.eq(BaseAttrInfo::getId,baseAttrInfo.getId());
        }
        //判断名字
        if(baseAttrInfo.getAttrName() != null){
            baseAttrInfoLambdaQueryWrapper.like(BaseAttrInfo::getAttrName,baseAttrInfo.getAttrName());
        }
        //判断分类id
        if(baseAttrInfo.getCategoryId() != null){
            baseAttrInfoLambdaQueryWrapper.eq(BaseAttrInfo::getCategoryId,baseAttrInfo.getCategoryId());
        }

        return baseAttrInfoLambdaQueryWrapper;
    }
}
